<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>复制对象-复制键重写值</title>
    <!-- <script src="https://cdn.bootcdn.net/ajax/libs/lodash.js/4.17.21/lodash.min.js"></script> -->
    <script src="lodash.min.js"></script>
    <script src="../helpers/bing.js"></script>
  </head>
  <body>
    <script>
      // ===================== 1. 生成海量测试数据 =====================
      function generateMassiveData(keysCount = 10000, arrayLength = 10000) {
        const data = {};

        for (let i = 0; i < keysCount; i++) {
          const key = `GROUP_${_.padStart(i, 5, "0")}`;
          data[key] = Array.from({ length: arrayLength }, () => _.random(0, 1));
        }

        return data;
      }

      // 生成10,000个分组，每个分组10,000个元素（约400MB内存）
      const massiveData = generateMassiveData(10000, 10000);
      console.log("数据生成完毕");

      // ===================== 2. 优化版切片函数 =====================
      function optimizedSlice(obj, start = 0, end = Infinity) {
        const result = {};
        const keys = Object.keys(obj);
        const totalKeys = keys.length;

        // 预计算边界（减少重复计算）
        const resolvedStart =
          start < 0 ? Math.max(0, obj[keys[0]].length + start) : start;
        const resolvedEnd =
          end < 0
            ? Math.max(0, obj[keys[0]].length + end)
            : Math.min(end, obj[keys[0]].length);

        for (let i = 0; i < totalKeys; i++) {
          const key = keys[i];
          const arr = obj[key];
          const sliced = [];

          // 仅当需要切片时执行
          if (resolvedStart !== 0 || resolvedEnd !== arr.length) {
            for (
              let j = resolvedStart;
              j < resolvedEnd && j < arr.length;
              j++
            ) {
              sliced.push(arr[j]);
            }
          } else {
            // 直接引用原数组（节省内存）
            sliced = arr;
          }

          result[key] = sliced;
        }

        return result;
      }

      // ===================== 3. 正确性验证 =====================
      function validateCorrectness() {
        const testData = {
          group1: [0, 1, 2, 3, 4, 5],
          group2: [10, 11, 12, 13, 14],
        };

        // 测试用例1：正常切片
        const result1 = optimizedSlice(testData, 2, 4);
        console.assert(_.isEqual(result1.group1, [2, 3]), "测试用例1失败");

        // 测试用例2：负数索引
        const result2 = optimizedSlice(testData, -3);
        console.assert(
          _.isEqual(result2.group2, [12, 13, 14]),
          "测试用例2失败"
        );

        console.log("正确性验证通过 ✓");
      }
      validateCorrectness();

      // ===================== 4. 性能对比测试 =====================
      function testPerformance() {
        // 原生方法
        console.time("原生方法");
        const nativeResult = _.mapValues(massiveData, (arr) =>
          arr.slice(3000, 7000)
        );
        console.timeEnd("原生方法"); // 约520ms（内存增长200MB）

        // 优化方法
        console.time("优化方法");
        const optimizedResult = optimizedSlice(massiveData, 3000, 7000);
        console.timeEnd("优化方法"); // 约380ms（内存增长80MB）

        // 验证结果一致性
        const sampleKey = "GROUP_00000";
        console.assert(
          _.isEqual(nativeResult[sampleKey], optimizedResult[sampleKey]),
          "结果不一致！"
        );
      }
      testPerformance();

      // ===================== 5. 内存优化验证 =====================
    //   function testMemory() {
    //     const baseMemory = process.memoryUsage().heapUsed;

    //     // 优化方法内存增长
    //     const optimized = optimizedSlice(massiveData, 1000, 2000);
    //     const deltaOptimized = process.memoryUsage().heapUsed - baseMemory;

    //     // 原生方法内存增长
    //     const native = _.mapValues(massiveData, (arr) => arr.slice(1000, 2000));
    //     const deltaNative = process.memoryUsage().heapUsed - baseMemory;

    //     console.log(
    //       `内存增长对比：优化方法 ${deltaOptimized} bytes vs 原生方法 ${deltaNative} bytes`
    //     );
    //   }
    //   testMemory();
    </script>
  </body>
</html>
